package com.it.you.base.designmode.singleton;

import java.util.concurrent.atomic.AtomicLong;

public class IdGenerator_LanHan {
    private AtomicLong id = new AtomicLong(0);
    private static IdGenerator_LanHan instance ;

    private IdGenerator_LanHan() {

    }

    //懒汉式的缺点也很明显，我们给 getInstance() 这个方法加了一把大锁（synchronized）
    //导致这个函数的并发度很低。量化一下的话，并发度是 1，也就相当于
    //串行操作了。而这个函数是在单例使用期间，一直会被调用。如果这个单例类偶尔会被用
    //到，那这种实现方式还可以接受。但是，如果频繁地用到，那频繁加锁、释放锁及并发度低
    //等问题，会导致性能瓶颈，这种实现方式就不可取了
    public static synchronized IdGenerator_LanHan getInstance() {
        if ( instance == null) {
            instance = new IdGenerator_LanHan();
        }
        return instance;
    }

    public long getId() {
        return id.incrementAndGet();
    }

    //===============================性能优化==========================================
    private static volatile IdGenerator_LanHan instance_2 ;

    public static IdGenerator_LanHan getInstance_2() {
        if (instance_2 == null) {
            synchronized (IdGenerator_LanHan.class) {//类锁
                if (instance_2 == null ) { //双重检查 防止创建多个实例
                    instance_2 = new IdGenerator_LanHan();
                }
            }
        }
        return instance_2;
    }

}
